#include <stdio.h>
#if 0
#include "geometry.h"
#else
#include <math.h>

typedef struct { double x, y; } Point;
typedef struct { double a, b, c; } Line;
typedef struct { Point O; double rsq; } Circle;

double distance_squared(const Point P1, const Point P2)
{
    double dx = P1.x - P2.x;
    double dy = P1.y - P2.y;
    return dx * dx + dy * dy;
}

Point circle_center(Circle C)
{
    return C.O;
}

Circle apollonian_circle(const Point P1, const Point P2, double ratio)
{
    double x1 = P1.x, y1 = P1.y, x2 = P2.x, y2 = P2.y;
    double t = ratio * ratio;
    Circle C;
    C.rsq = ((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))*t/((1-t)*(1-t));
    C.O.x = (x1-t*x2)/(1-t);
    C.O.y = (y1-t*y2)/(1-t);
    return C;
}

int intersect_line_circle(const Line L, const Circle C, Point P[2])
{
    double x0 = C.O.x, y0 = C.O.y;
    double a = L.a, b = L.b, c = L.c + a*x0 + b*y0;
    double delta = (a*a+b*b)*C.rsq - c*c;
    if (delta >= 0)
    {
        P[0].x = x0 + (-a*c+b*sqrt(delta))/(a*a+b*b);
        P[0].y = y0 + (-b*c-a*sqrt(delta))/(a*a+b*b);
        P[1].x = x0 + (-a*c-b*sqrt(delta))/(a*a+b*b);
        P[1].y = y0 + (-b*c+a*sqrt(delta))/(a*a+b*b);
        return 2;
    }
    return 0;
}

Line radical_line(const Circle C1, const Circle C2)
{
    double x1 = C1.O.x, y1 = C1.O.y, r1sq = C1.rsq;
    double x2 = C2.O.x, y2 = C2.O.y, r2sq = C2.rsq;
    Line L;
    L.a = 2*(x1-x2);
    L.b = 2*(y1-y2);
    L.c = (r1sq-r2sq) - (x1+x2)*(x1-x2) - (y1+y2)*(y1-y2);
    return L;
}

int intersect_circles(const Circle C1, const Circle C2, Point P[2])
{
    return intersect_line_circle(radical_line(C1, C2), C1, P);
}

Point circumcenter(const Point P[3])
{
    double x0 = P[0].x, y0 = P[0].y;
    double x1 = P[1].x, y1 = P[1].y;
    double x2 = P[2].x, y2 = P[2].y;
    double t = ((x1-x0)*(x2-x0)+(y1-y0)*(y2-y0)) / 
               ((x1-x0)*(y2-y0)-(x2-x0)*(y1-y0));
    Point O;
    O.x = ((x1+x2)+t*(y1-y2)) / 2;
    O.y = ((y1+y2)-t*(x1-x2)) / 2;
    return O;
}
#endif

#define SWAP(Ty, a, b) do { Ty _tmp = (a); (a) = (b); (b) = _tmp; } while (0)

#if _DEBUG
double distance(const Point P1, const Point P2)
{
    double dx = P1.x - P2.x;
    double dy = P1.y - P2.y;
    return sqrt(dx * dx + dy * dy);
}

static void verify(Point Q, Point P[3], double r[3])
{
    int i;
    for (i = 0; i < 3; i++)
        printf("sin(%d) = %.6lf\n", i+1, r[i]/distance(Q,P[i]));
}
#endif

int main()
{
    Point P[3];     /* center of the circles */
    double r[3];    /* radii of the circles */
    while (scanf("%lf %lf %lf %lf %lf %lf %lf %lf %lf", 
           &P[0].x, &P[0].y, &r[0],
           &P[1].x, &P[1].y, &r[1],
           &P[2].x, &P[2].y, &r[2]) == 9 && r[0] != 0)
    {
        if (r[0] == r[1] && r[0] == r[2]) /* intersect two lines */
        {
            Point Q = circumcenter(P);
            printf("%.2lf %.2lf\n", Q.x, Q.y);
        }
        else /* either r[0] != r[1] or r[0] != r[2] */
        {
            Point Q[2];     /* intersection points */
            Circle A1, A2;
            if (r[0] == r[1]) /* r[0] == r[1] != r[2] */
            {
                SWAP(Point, P[0], P[2]);
                SWAP(double, r[0], r[2]);
            }
            if (r[0] == r[2]) /* r[0] == r[2] != r[1] */
            {
                SWAP(Point, P[0], P[1]);
                SWAP(double, r[0], r[1]);
            }
            A1 = apollonian_circle(P[0], P[1], r[0] / r[1]);
            A2 = apollonian_circle(P[0], P[2], r[0] / r[2]);
            if (intersect_circles(A1, A2, Q) == 2)
            {
                /* Find the closer point. */
                double d1_sq = distance_squared(Q[0], P[0]);
                double d2_sq = distance_squared(Q[1], P[0]);
                int i = (d1_sq < d2_sq)? 0 : 1;
                printf("%.2lf %.2lf\n", Q[i].x, Q[i].y);
#if _DEBUG
                verify(Q[i], P, r);
#endif
            }
            else
                printf("No solution\n");
        }
    }
    return 0;
}
